---
title: "Context Management"
description: "Context is key to getting the most out of Cline"
---

> **Quick Reference**
>
> -   Context = The information Cline knows about your project
> -   Context Window = How much information Cline can hold at once
> -   Use context files to maintain project knowledge
> -   Reset when the context window gets full

## Understanding Context & Context Windows

<Frame caption="In a world of infinite context, the context window is what Cline currently has available">
	<img
		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(2).png"
		alt="In a world of infinite context, the context window is what Cline currently has available"
	/>
</Frame>

Think of working with Cline like collaborating with a thorough, proactive teammate:

### How Context is Built

Cline actively builds context in two ways:

1. **Automatic Context Gathering (i.e. Cline-driven)**
    - Proactively reads related files
    - Explores project structure
    - Analyzes patterns and relationships
    - Maps dependencies and imports
    - Asks clarifying questions
2. **User-Guided Context**
    - Share specific files
    - Provide documentation
    - Answer Cline's questions
    - Guide focus areas
    - Share design thoughts and requirements

**Key Point**: Cline isn't passive - it actively seeks to understand your project. You can either let it explore or guide its focus, especially in [Plan Mode](/features/plan-and-act).

### Context & Context Windows

Think of context like a whiteboard you and Cline share:

-   **Context** is all the information available:
    -   What Cline has discovered
    -   What you've shared
    -   Your conversation history
    -   Project requirements
    -   Previous decisions
-   **Context Window** is the size of the whiteboard itself:
    -   Measured in tokens (1 token ≈ 3/4 of an English word)
    -   Each model has a fixed size:
        -   Claude Sonnet 4: 1,000,000 tokens
        -   Qwen3 Coder: 256,000 tokens
        -   Gemini 2.5 Pro: 1,000,000+ tokens
        -   GPT-5: 400,000 tokens
    -   When the whiteboard is full, Cline automatically summarizes the conversation to free up space

**Important**: Having a large context window doesn't mean you should fill it completely. Models start degrading around 400-500K tokens even if they claim higher limits. Just like a cluttered whiteboard, too much information can make it harder to focus on what's important.

## Understanding the Context Window Progress Bar

Cline provides a visual way to monitor your context window usage through a progress bar:

<Frame caption="Visual representation of the context window usage">
	<img
		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(1)%20(1).png"
		alt="Context window progress bar"
	/>
</Frame>

### Reading the Bar

-   ↑ shows input tokens (what you've sent to the LLM)
-   ↓ shows output tokens (what the LLM has generated)
-   The progress bar visualizes how much of your context window you've used
-   The total shows your model's maximum capacity (e.g., 1M for Claude Sonnet 4)

### When to Watch the Bar

-   During long coding sessions
-   When working with multiple files
-   Before starting complex tasks
-   When Cline seems to lose context

**Tip**: With [Auto Compact](/features/auto-compact), Cline can now handle long conversations automatically. When combined with [Focus Chain](/features/focus-chain), you can work on complex projects that span multiple context windows without losing progress.

## Automatic Context Management

Cline includes intelligent features to manage context automatically:

### Default Settings You Should Keep On

**Focus Chain** - Enabled by default in v3.25. Cline generates a todo list at task start and keeps it in context so the thread doesn't drift. You can edit the markdown to add or reorder steps and Cline will adapt. [Learn more about Focus Chain](/features/focus-chain).

**Auto Compact** - Always on. As the context window reaches its limit, Cline creates a comprehensive summary, replaces the bloated history, and continues where it left off. Decisions, code changes, and state are preserved. [Learn more about Auto Compact](/features/auto-compact).

## Advanced Context Tools

When you need more control over context management:

### Deep Planning (`/deep-planning`)
For substantial features, refactors, or integrations. Cline investigates your codebase, asks targeted questions, then writes `implementation_plan.md`. It creates a fresh task with distilled, high-value context. [Learn more about Deep Planning](/features/slash-commands/deep-planning).

### New Task (`/newtask`)
At natural transition points, packages only what matters into a fresh task. Clean slate for implementation after research, or crisp handoff between teammates. [Learn more about New Task](/features/slash-commands/new-task).

### Smol (`/smol`)
Compress the conversation in place to keep momentum. Ideal during debugging or exploratory work when you don't want to break flow. [Learn more about Smol](/features/slash-commands/smol).

### Memory Bank + .clinerules
For non-trivial projects. The Memory Bank captures project knowledge as Markdown in your repo. `.clinerules` are version-controlled instructions that align Cline's behavior with your team. [Learn more about Memory Bank](/prompting/cline-memory-bank) and [Cline Rules](/features/cline-rules).

## Working with Context Files

Context files help maintain understanding across sessions. They serve as documentation specifically designed to help AI assistants understand your project.

#### Approaches to Context Files

1. **Evergreen Project Context (Memory Bank)**
    - Living documentation that evolves with your project
    - Updated as architecture and patterns emerge
    - Example: The Memory Bank pattern maintains files like `techContext.md` and `systemPatterns.md`
    - Useful for long-running projects and teams
2. **Task-Specific Context**

    - Created for specific implementation tasks
    - Document requirements, constraints, and decisions
    - Example:

        ```markdown
        # auth-system-implementation.md

        ## Requirements

        -   OAuth2 implementation
        -   Support for Google and GitHub
        -   Rate limiting on auth endpoints

        ## Technical Decisions

        -   Using Passport.js for provider integration
        -   JWT for session management
        -   Redis for rate limiting
        ```

3. **Knowledge Transfer Docs**
    - Switch to plan mode and ask Cline to document everything you've accomplished so far, along with the remaining steps, in a markdown file.
    - Copy the contents of the markdown file.
    - Start a new task using that content as context.

#### Using Context Files Effectively

1. **Structure and Format**
    - Use clear, consistent organization
    - Include relevant examples
    - Link related concepts
    - Keep information focused
2. **Maintenance**
    - Update after significant changes
    - Version control your context files
    - Remove outdated information
    - Document key decisions

## Practical Tips

1. **Starting New Projects**
    - Let Cline explore the codebase
    - Answer its questions about structure and patterns
    - Consider setting up basic context files
    - Document key design decisions
2. **Ongoing Development**
    - Update context files with significant changes
    - Share relevant documentation
    - Use Plan mode for complex discussions
    - Start fresh sessions when needed
3. **Team Projects**
    - Share common context files (consider using [.clinerules](/features/cline-rules) files in project roots)
    - Document architectural decisions
    - Maintain consistent patterns
    - Keep documentation current

## Bonus Context Tips

- You can @ links and have the webpage's context added to Cline (docs, blogs, etc.)
- Utilize MCP servers to pull in context from your external knowledge bases
- Screenshots can be used as context for models that support image inputs

## The Bottom Line

Cline already does a lot of context work for you - [Focus Chain](/features/focus-chain), [Auto Compact](/features/auto-compact), and the planning flow are designed to keep the thread intact across long horizons. The goal is to help Cline maintain consistent understanding of your project across sessions.

Remember: The goal is to keep only what matters in view, at every step.
